Mestring af avancerede Pytest Fixtures: Parametriseret testning og mock-integration

Pytest er et kraftfuldt og fleksibelt test-framework til Python. Dets enkelhed og udvidelsesmuligheder gør det til en favorit blandt udviklere verden over. En af Pytests mest overbevisende funktioner er dets fixture-system, som muliggør elegante og genanvendelige test-setups. Dette blogindlæg dykker ned i avancerede fixture-teknikker med særligt fokus på parametriseret testning og mock-integration. Vi vil udforske, hvordan disse teknikker kan forbedre din test-workflow betydeligt, hvilket fører til mere robust og vedligeholdelsesvenlig kode.

Forståelse af Pytest Fixtures

Før vi dykker ned i avancerede emner, lad os kort opsummere det grundlæggende om Pytest fixtures. En fixture er en funktion, der kører før hver testfunktion, den anvendes på. Den bruges til at skabe et fast udgangspunkt for tests, hvilket sikrer konsistens og reducerer overflødig kode. Fixtures kan udføre opgaver som:

• Opsætning af en databaseforbindelse
• Oprettelse af midlertidige filer eller mapper
• Initialisering af objekter med specifikke konfigurationer
• Autentificering med en API

Fixtures fremmer genbrugelighed af kode og gør dine tests mere læsbare og vedligeholdelsesvenlige. De kan defineres med forskellige scopes (function, module, session) for at styre deres levetid og ressourceforbrug.

Eksempel på en grundlæggende Fixture

Her er et simpelt eksempel på en Pytest fixture, der opretter en midlertidig mappe:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

For at bruge denne fixture i en test skal du blot inkludere den som et argument i din testfunktion:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

Parametriseret testning med Pytest

Parametriseret testning giver dig mulighed for at køre den samme testfunktion flere gange med forskellige sæt inputdata. Dette er især nyttigt til at teste funktioner med varierende input og forventede output. Pytest tilbyder @pytest.mark.parametrize-dekoratoren til at implementere parametriserede tests.

Fordele ved parametriseret testning

• Reducerer kodeduplikering: Undgå at skrive flere næsten identiske testfunktioner.
• Forbedrer testdækning: Test nemt et bredere udvalg af inputværdier.
• Forbedrer testlæsbarhed: Definer klart inputværdierne og de forventede output for hver testcase.

Eksempel på grundlæggende parametrisering

Lad os sige, du har en funktion, der lægger to tal sammen:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Du kan bruge parametriseret testning til at teste denne funktion med forskellige inputværdier:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

I dette eksempel definerer @pytest.mark.parametrize-dekoratoren fire testcases, hver med forskellige værdier for x, y og det forventede resultat. Pytest vil køre test_add-funktionen fire gange, én gang for hvert sæt af parametre.

Avancerede parametriseringsteknikker

Pytest tilbyder flere avancerede teknikker til parametrisering, herunder:

• Brug af Fixtures med parametrisering: Kombiner fixtures med parametrisering for at levere forskellige opsætninger for hver testcase.
• ID'er for testcases: Tildel brugerdefinerede ID'er til testcases for bedre rapportering og fejlfinding.
• Indirekte parametrisering: Parametriser argumenterne, der sendes til fixtures, hvilket muliggør dynamisk oprettelse af fixtures.

Brug af Fixtures med parametrisering

Dette giver dig mulighed for dynamisk at konfigurere fixtures baseret på de parametre, der sendes til testen. Forestil dig, at du tester en funktion, der interagerer med en database. Du vil måske bruge forskellige databasekonfigurationer (f.eks. forskellige forbindelsesstrenge) til forskellige testcases.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simuler oprettelse af en databaseforbindelse
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Din testlogik her, ved brug af db_connection-fixturen
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

I dette eksempel er db_config-fixturen parametriseret. Argumentet indirect=True fortæller Pytest, at det skal sende parametrene ("prod" og "test") til db_config-fixture-funktionen. db_config-fixturen returnerer derefter forskellige databasekonfigurationer baseret på parameterværdien. db_connection-fixturen bruger db_config-fixturen til at oprette en databaseforbindelse. Til sidst bruger test_database_interaction-funktionen db_connection-fixturen til at interagere med databasen.

ID'er for testcases

Brugerdefinerede ID'er giver mere beskrivende navne til dine testcases i testrapporten, hvilket gør det lettere at identificere og fejlfinde fejl.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

Uden ID'er ville Pytest generere generiske navne som test_uppercase[0], test_uppercase[1] osv. Med ID'er vil testrapporten vise mere meningsfulde navne som test_uppercase[lowercase_hello].

Indirekte parametrisering

Indirekte parametrisering giver dig mulighed for at parametrisere inputtet til en fixture i stedet for direkte til testfunktionen. Dette er nyttigt, når du vil oprette forskellige fixture-instanser baseret på parameterværdien.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

I dette eksempel er input_data-fixturen parametriseret med værdierne "valid" og "invalid". Argumentet indirect=True fortæller Pytest, at det skal sende disse værdier til input_data-fixture-funktionen. input_data-fixturen returnerer derefter forskellige data-ordbøger baseret på parameterværdien. test_validate_data-funktionen bruger derefter input_data-fixturen til at teste validate_data-funktionen med forskellige inputdata.

Mocking med Pytest

Mocking er en teknik, der bruges til at erstatte reelle afhængigheder med kontrollerede substitutter (mocks) under test. Dette giver dig mulighed for at isolere den kode, der testes, og undgå at være afhængig af eksterne systemer som databaser, API'er eller filsystemer.

Fordele ved mocking

• Isoler kode: Test kode isoleret uden at være afhængig af eksterne afhængigheder.
• Kontroller adfærd: Definer adfærden for afhængigheder, såsom returværdier og undtagelser.
• Gør tests hurtigere: Undgå langsomme eller upålidelige eksterne systemer.
• Test kanttilfælde: Simuler fejltilstande og kanttilfælde, der er svære at gengive i et virkeligt miljø.

Brug af unittest.mock-biblioteket

Python tilbyder unittest.mock-biblioteket til at oprette mocks. Pytest integreres problemfrit med unittest.mock, hvilket gør det nemt at mocke afhængigheder i dine tests.

Eksempel på grundlæggende mocking

Lad os sige, du har en funktion, der henter data fra en ekstern API:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Rejs en undtagelse for dårlige statuskoder
    return response.json()

            

              
                Copy
              
            
          

For at teste denne funktion uden rent faktisk at sende en anmodning til API'en kan du mocke requests.get-funktionen:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Konfigurer mock'en til at returnere et specifikt svar
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Kald den funktion, der testes
    data = get_data_from_api("https://example.com/api")

    # Bekræft, at mock'en blev kaldt med den korrekte URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Bekræft, at funktionen returnerede de forventede data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

I dette eksempel erstatter @patch("requests.get")-dekoratoren requests.get-funktionen med et mock-objekt. Argumentet mock_get er mock-objektet. Vi kan derefter konfigurere mock-objektet til at returnere et specifikt svar og bekræfte, at det blev kaldt med den korrekte URL.

Mocking med Fixtures

Du kan også bruge fixtures til at oprette og administrere mocks. Dette kan være nyttigt til at dele mocks på tværs af flere tests eller til at skabe mere komplekse mock-opsætninger.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Kald den funktion, der testes
    data = get_data_from_api("https://example.com/api")

    # Bekræft, at mock'en blev kaldt med den korrekte URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Bekræft, at funktionen returnerede de forventede data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Her opretter mock_api_get en mock og returnerer den. patched_get bruger derefter monkeypatch, en pytest-fixture, til at erstatte den rigtige `requests.get` med mock'en. Dette giver andre tests mulighed for at bruge det samme mockede API-endepunkt.

Avancerede mocking-teknikker

Pytest og unittest.mock tilbyder flere avancerede mocking-teknikker, herunder:

• Side Effects (Bivirkninger): Definer brugerdefineret adfærd for mocks baseret på de input-argumenter, de modtager.
• Property Mocking: Mock egenskaber (properties) på objekter.
• Context Managers: Brug mocks inden for context managers til midlertidige erstatninger.

Side Effects (Bivirkninger)

Side effects (bivirkninger) giver dig mulighed for at definere brugerdefineret adfærd for dine mocks baseret på de input-argumenter, de modtager. Dette er nyttigt til at simulere forskellige scenarier eller fejltilstande.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

Denne mock returnerer 1, 2 og 3 ved efterfølgende kald og rejser derefter en `StopIteration`-undtagelse, når listen er opbrugt.

Property Mocking

Property mocking giver dig mulighed for at mocke adfærden af egenskaber (properties) på objekter. Dette er nyttigt til at teste kode, der er afhængig af objekt-egenskaber frem for metoder.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

Dette eksempel mocker my_property-egenskaben på MyClass-objektet, hvilket giver dig mulighed for at kontrollere dens returværdi under testen.

Context Managers

Brug af mocks inden for context managers giver dig mulighed for midlertidigt at erstatte afhængigheder for en specifik kodeblok. Dette er nyttigt til at teste kode, der interagerer med eksterne systemer eller ressourcer, der kun skal mockes i en begrænset periode.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # Mock'en gendannes automatisk efter 'with'-blokken
    # Sikr, at den oprindelige funktion er gendannet, selvom vi ikke rigtig kan bekræfte
    # den rigtige `os.path.exists` funktions adfærd uden en rigtig sti.
    # Det vigtige er, at patchen er væk efter konteksten.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Kombination af parametrisering og mocking

Disse to kraftfulde teknikker kan kombineres for at skabe endnu mere sofistikerede og effektive tests. Du kan bruge parametrisering til at teste forskellige scenarier med forskellige mock-konfigurationer.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

I dette eksempel er test_get_user_data-funktionen parametriseret med forskellige user_id- og expected_data-værdier. @patch-dekoratoren mocker requests.get-funktionen. Pytest vil køre testfunktionen to gange, én gang for hvert sæt af parametre, hvor mock'en er konfigureret til at returnere de tilsvarende expected_data.

Bedste praksis for brug af avancerede Fixtures

• Hold Fixtures fokuserede: Hver fixture bør have et klart og specifikt formål.
• Brug passende Scopes: Vælg det passende fixture-scope (function, module, session) for at optimere ressourceforbruget.
• Dokumenter Fixtures: Dokumenter tydeligt formålet med og brugen af hver fixture.
• Undgå overdreven Mocking: Mock kun de afhængigheder, der er nødvendige for at isolere den kode, der testes.
• Skriv klare Assertions: Sørg for, at dine assertions er klare og specifikke og verificerer den forventede adfærd af den kode, der testes.
• Overvej testdrevet udvikling (TDD): Skriv dine tests, før du skriver koden, og brug fixtures og mocks til at guide udviklingsprocessen.

Konklusion

Pytests avancerede fixture-teknikker, herunder parametriseret testning og mock-integration, giver kraftfulde værktøjer til at skrive robuste, effektive og vedligeholdelsesvenlige tests. Ved at mestre disse teknikker kan du markant forbedre kvaliteten af din Python-kode og strømline din test-workflow. Husk at fokusere på at skabe klare, fokuserede fixtures, bruge passende scopes og skrive omfattende assertions. Med øvelse vil du kunne udnytte det fulde potentiale i Pytests fixture-system til at skabe en omfattende og effektiv teststrategi.